import Settings from '../config/Settings.js';

export default class Platform {
  constructor(game, options = {}) {
    this.game = game;
    
    this.x = options.x || game.canvas.width;
    this.y = options.y || 0;
    this.type = options.type || 'normal';
    this.width = options.width || Settings.platform.width;
    this.height = options.height || Settings.platform.height;
    
    // 获取平台类型配置
    const typeConfig = Settings.platform.types[this.type] || Settings.platform.types.normal;
    
    // 平台颜色
    this.color = typeConfig.color || '#996515'; // 默认中等棕色
    
    // 特殊平台属性
    switch(this.type) {
      case 'bouncy':
        this.bounceFactor = typeConfig.bounceFactor || 1.5;
        break;
        
      case 'icy':
        this.friction = typeConfig.friction || 0.98;
        break;
        
      case 'crumbling':
        this.crumbleTime = typeConfig.crumbleTime || 45;
        this.crumbling = false;
        this.crumbleTimer = 0;
        this.cracks = [];
        break;
        
      case 'moving':
        this.initialY = this.y;
        this.moveDirection = 1; // 1: 向下, -1: 向上
        this.moveDistance = typeConfig.moveDistance || 100;
        this.moveSpeed = typeConfig.moveSpeed || 1.5;
        break;
        
      case 'secret': // 隐藏区域的特殊平台
        this.color = 'rgba(255, 215, 0, 0.8)'; // 半透明金色
        this.hasSpecialEffect = true;
        break;
    }
  }
  
  update() {
    // 平台向左移动
    this.x -= Settings.platform.speed;
    
    // 特殊平台逻辑
    switch(this.type) {
      case 'crumbling':
        if (this.crumbling) {
          this.crumbleTimer++;
          
          // 生成裂纹特效
          if (this.crumbleTimer % 10 === 0 && this.cracks.length < 5) {
            this.cracks.push({
              x: Math.random() * this.width,
              y: Math.random() * this.height,
              length: Math.random() * 20 + 10,
              angle: Math.random() * Math.PI
            });
          }
          
          // 平台消失检查
          if (this.crumbleTimer >= this.crumbleTime) {
            return true; // 标记为需要移除
          }
        }
        break;
        
      case 'moving':
        // 上下移动
        this.y += this.moveSpeed * this.moveDirection;
        
        // 检查移动边界
        if (Math.abs(this.y - this.initialY) >= this.moveDistance) {
          this.moveDirection *= -1; // 反转方向
        }
        break;
    }
    
    return false; // 默认不移除
  }
  
  render(ctx) {
    ctx.save();
    
    // 绘制平台阴影
    ctx.fillStyle = 'rgba(0, 0, 0, 0.2)';
    ctx.fillRect(this.x + 5, this.y + 5, this.width, this.height);
    
    // 绘制平台主体
    ctx.fillStyle = this.color;
    ctx.fillRect(this.x, this.y, this.width, this.height);
    
    // 添加顶部边缘高亮，使平台更易于辨认
    ctx.strokeStyle = 'rgba(255, 255, 255, 0.5)';
    ctx.lineWidth = 2;
    ctx.beginPath();
    ctx.moveTo(this.x, this.y);
    ctx.lineTo(this.x + this.width, this.y);
    ctx.stroke();
    
    // 绘制调试信息
    if (this.game.debugMode) {
      // 显示碰撞区域
      ctx.strokeStyle = 'rgba(255, 0, 0, 0.7)';
      ctx.lineWidth = 1;
      ctx.strokeRect(this.x, this.y - 10, this.width, 15);
      
      // 显示平台类型信息
      ctx.fillStyle = 'white';
      ctx.font = '10px Arial';
      ctx.textAlign = 'center';
      ctx.fillText(this.type, this.x + this.width/2, this.y - 15);
    }
    
    // 特殊平台外观
    switch(this.type) {
      case 'bouncy':
        // 弹跳平台特效 - 波浪纹理
        ctx.strokeStyle = 'rgba(255, 255, 255, 0.7)';
        ctx.lineWidth = 2;
        ctx.beginPath();
        for (let i = 0; i < this.width; i += 15) {
          const amplitude = 3;
          const frequency = 0.2;
          const offsetY = Math.sin(i * frequency + this.game.gameTime * 0.1) * amplitude;
          ctx.moveTo(this.x + i, this.y + this.height/2 + offsetY);
          ctx.lineTo(this.x + i + 10, this.y + this.height/2 - offsetY);
        }
        ctx.stroke();
        break;
        
      case 'icy':
        // 冰面平台特效 - 光泽反射
        const gradient = ctx.createLinearGradient(this.x, this.y, this.x, this.y + this.height);
        gradient.addColorStop(0, 'rgba(255, 255, 255, 0.8)');
        gradient.addColorStop(0.5, 'rgba(255, 255, 255, 0.2)');
        gradient.addColorStop(1, 'rgba(255, 255, 255, 0.4)');
        ctx.fillStyle = gradient;
        ctx.fillRect(this.x, this.y, this.width, this.height/2);
        break;
        
      case 'crumbling':
        // 碎裂平台特效
        if (this.crumbling) {
          // 绘制裂纹
          ctx.strokeStyle = 'rgba(101, 67, 33, 0.8)';
          ctx.lineWidth = 2;
          for (const crack of this.cracks) {
            ctx.beginPath();
            ctx.moveTo(this.x + crack.x, this.y + crack.y);
            ctx.lineTo(
              this.x + crack.x + Math.cos(crack.angle) * crack.length,
              this.y + crack.y + Math.sin(crack.angle) * crack.length
            );
            ctx.stroke();
          }
          
          // 平台摇晃效果
          if (this.crumbleTimer > this.crumbleTime * 0.6) {
            const shakeAmount = (Math.random() - 0.5) * 4;
            ctx.translate(shakeAmount, 0);
          }
        }
        break;
        
      case 'secret':
        // 隐藏平台特效 - 金色光晕
        const glowRadius = 10 + Math.sin(this.game.gameTime * 0.1) * 5;
        ctx.shadowColor = 'rgba(255, 215, 0, 0.6)';
        ctx.shadowBlur = glowRadius;
        ctx.fillStyle = 'rgba(255, 215, 0, 0.8)';
        ctx.fillRect(this.x, this.y, this.width, this.height);
        break;
    }
    
    ctx.restore();
  }
  
  // 检查是否在屏幕外
  isOffScreen() {
    return this.x + this.width < 0;
  }
  
  // 判断玩家是否在平台上方
  isPlayerAbove(player) {
    // 确保参数有效
    if (!player) return false;
    
    // 获取玩家的底部中心坐标和碰撞盒
    const playerBottomY = player.y + player.height;
    const playerCenterX = player.x;
    const playerLeftEdge = playerCenterX - player.width/3;
    const playerRightEdge = playerCenterX + player.width/3;
    
    // 平台的碰撞盒
    const platformTopY = this.y;
    const platformLeftEdge = this.x;
    const platformRightEdge = this.x + this.width;
    
    // 垂直碰撞检测：玩家正在下落且底部接近平台顶部
    // 1. 垂直速度必须是正数（表示下落）或接近0（刚开始下落）
    // 2. 玩家底部必须接近平台顶部（上下10像素的容差）
    const verticalCheck = 
      player.verticalVelocity >= 0 && // 必须是下落状态
      playerBottomY >= platformTopY - 10 && // 玩家底部略高于平台顶部
      playerBottomY <= platformTopY + 10;   // 玩家底部略低于平台顶部
    
    // 水平碰撞检测：玩家必须在平台的水平范围内
    const horizontalCheck = 
      playerRightEdge >= platformLeftEdge && // 玩家右边缘超过平台左边缘
      playerLeftEdge <= platformRightEdge;   // 玩家左边缘在平台右边缘之前
    
    // 调试信息 - 每60帧记录一次接近但未触发的情况
    if (this.game.debugMode && this.game.gameTime % 60 === 0 && 
        Math.abs(playerBottomY - platformTopY) < 30 && 
        horizontalCheck && 
        !verticalCheck) {
      console.log('接近平台但未触发碰撞:', {
        playerPos: {x: playerCenterX, y: player.y, bottomY: playerBottomY},
        verticalVelocity: player.verticalVelocity,
        platformPos: {x: this.x, y: this.y, width: this.width},
        type: this.type,
        gap: playerBottomY - platformTopY
      });
    }
    
    // 如果在平台上方，添加视觉反馈
    if (verticalCheck && horizontalCheck && this.game.debugMode) {
      // 创建一个小的粒子效果以提高视觉反馈
      if (this.game.particleSystem && this.game.gameTime % 5 === 0) {
        this.game.particleSystem.createParticles(
          playerCenterX,
          platformTopY,
          "#FFFFFF",
          3,
          1,
          2,
          10
        );
      }
      
      // 记录碰撞成功信息
      if (this.game.gameTime % 120 === 0) {
        console.log('平台碰撞成功:', {
          platform: {x: this.x, y: this.y, type: this.type},
          player: {x: playerCenterX, y: player.y, vy: player.verticalVelocity}
        });
      }
    }
    
    // 返回最终的碰撞结果
    return verticalCheck && horizontalCheck;
  }
  
  // 应用平台效果
  applyEffect(player) {
    // 根据平台类型应用不同效果
    switch (this.type) {
      case 'bouncy':
        // 弹跳平台效果
        player.verticalVelocity = player.jumpForce * this.bounceFactor;
        
        // 创建弹跳粒子效果
        this.game.particleSystem.createParticles(
          player.x,
          this.y,
          '#00FF00',
          10,
          3,
          6,
          30
        );
        
        // 平台动画效果
        this.animationState = 'bounce';
        this.animationTimer = 0;
        
        // 表示效果已经应用，防止重复应用
        return true;
        
      case 'icy':
        // 冰面平台效果 - 水平移动速度保持不变（滑动）
        if (player.horizontalVelocity !== 0) {
          // 标记为已处理滑动
          this.hasAppliedIceEffect = true;
        }
        
        // 创建冰面粒子效果
        if (Math.random() < 0.1) {
          this.game.particleSystem.createParticles(
            player.x,
            this.y,
            '#FFFFFF',
            3,
            2,
            3,
            20
          );
        }
        
        return false; // 允许其他效果继续应用
        
      case 'crumbling':
        // 如果平台开始崩塌，不需要再次触发效果
        if (this.crumbling) return false;
        
        // 触发崩塌
        this.crumbling = true;
        this.crumbleTimer = 0;
        
        // 创建崩塌粒子效果
        this.game.particleSystem.createParticles(
          this.x + this.width/2,
          this.y,
          this.color,
          15,
          3,
          5,
          45
        );
        
        return false; // 允许其他效果继续应用
        
      case 'moving':
        // 移动平台不需要特殊处理
        return false;
        
      case 'secret':
        // 隐藏区域平台效果 - 可能奖励玩家
        if (this.hasSpecialEffect && Math.random() < 0.2) {
          // 20%的几率获得奖励
          this.game.scoreManager.addScore(50);
          this.game.floatingTexts.push({
            content: "秘密奖励 +50!",
            x: player.x,
            y: player.y - 30,
            color: '#FFD700',
            alpha: 1,
            velocity: -2
          });
          this.hasSpecialEffect = false; // 确保只触发一次
        }
        return false;
        
      default:
        // 普通平台不需要特殊处理
        return false;
    }
  }
} 